import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @Question t2
 * @Date 2023/2/9 20:47
 * @Solution
 */
public class t2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int m=scanner.nextInt();
        int[] num=new int[n];
        for(int i=0;i<n;i++) {
            num[i]=i+1;
        }
        String f=scanner.nextLine();
        for(int i=0;i<m;i++) {
            String op=scanner.nextLine();
            String[] strings = op.split(" ");
            if(strings[0].equals("1")) {
                sortBig(num, Integer.parseInt(strings[1]) - 1,num.length-1);
            } else {
                sortSmall(num,0,Integer.parseInt(strings[1]) - 1);
            }
        }
        for(int i=0;i<n;i++) {
            if(i==n-1) {
                System.out.print(num[i]);
            } else {
                System.out.print(num[i]+" ");
            }
        }
    }
    public static void sortBig(int[] a, int low, int high){
        int start = low;
        int end = high;
        int key = a[low];


        while(end>start){
            //从后往前比较
            while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if(a[end]<=key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if(a[start]>=key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if(start>low) sortBig(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
        if(end<high) sortBig(a,end+1,high);//右边序列。从关键值索引+1到最后一个
    }
    public static void sortSmall(int[] a, int low, int high){
        int start = low;
        int end = high;
        int key = a[low];


        while(end>start){
            //从后往前比较
            while(end>start&&a[end]<=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if(a[end]>=key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while(end>start&&a[start]>=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if(a[start]<=key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if(start>low) sortSmall(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
        if(end<high) sortSmall(a,end+1,high);//右边序列。从关键值索引+1到最后一个
    }
}
